// 4-2-2-4-3 类&对象-类 & 对象详解-类访问修饰符-继承中的特点-private继承
/**
 * C++ 类 & 对象
 * C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。
 * 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
 * 
 * ------------
 * 类 & 对象详解
 * 到目前为止，我们已经对 C++ 的类和对象有了基本的了解。下面的列表中还列出了其他一些 C++ 类和对象相关的概念，可以点击相应的链接进行学习。
 * 1. 类成员函数
 * 类的成员函数是指那些把定义和**原型**写在类定义内部的函数，就像类定义中的其他变量一样。
 * 
 * 2. 类访问修饰符
 * 类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
 * 
 * 3. 构造函数 & 析构函数
 * 类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
 * 
 * 4. C++ 拷贝构造函数
 * 拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
 * 
 * 5. C++ 友元函数
 * 友元函数可以访问类的 private 和 protected 成员。
 * 
 * 6. C++ 内联函数
 * 通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
 * 
 * 7. C++ 中的 this 指针
 * 每个对象都有一个特殊的指针 this，它指向对象本身。
 * 
 * 8. C++ 中指向类的指针
 * 指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
 * 
 * 9. C++ 类的静态成员
 * 类的数据成员和函数成员都可以被声明为静态的。
 * 
 * ~~~~~~~~~~~~~~~~~~~
 * 类访问修饰符
 * 数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
 * 一个类可以有**多个** public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

    class Base {
    
      public:
    
      // 公有成员
    
      protected:
    
      // 受保护成员
    
      private:
    
      // 私有成员
    
    };
    
 * ^^^^^^^^^^^^^^^^^^^^^^^^^
 * 继承中的特点
 * 有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。
      1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private

      2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

      3.private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

 * 但无论哪种继承方式，上面两点都没有改变：

    1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

    2.protected 成员可以被派生类访问。

 * ++++++++++++++++++++++++
 * private 继承 
 * 
*/

#include <iostream>

class A
{
public:
  int a;
  A()
  {
    a = 0;
    a1 = 1;
    a2 = 2;
    a3 = 3;
  }

public:
  int a1;

protected:
  int a2;

private:
  int a3;
};

class B : private A
{
public:
  int a;
  B(int i)
  {
    A();
    a = i;
  }
  void fun()
  {
    std::cout << "a : " << a << std::endl;
    std::cout << "a1 : " << a1 << std::endl;// 基类的public成员在派生类中变成private，可以访问
    std::cout << "a2 : " << a2 << std::endl;// 基类中protected成员 在派生类中变成private，可以访问
    // std::cout << "a3 : " << a3 << std::endl; // error: 'int A::a3' is private within this context  基类中private成员不能被派生类访问
  }
};

int main(void)
{
  /**
   * 示例一
  */
  B b1(10);
  std::cout << "b1.a : " << b1.a << std::endl;
  // std::cout << "b1.a1 : " << b1.a1 << std::endl;// error: 'int A::a1' is inaccessible within this context      private 成员不能在类外访问 
  // std::cout << "b1.a2 : " << b1.a2 << std::endl;// error: 'int A::a2' is protected within this context         private成员不能在类外访问
  // std::cout << "b1.a3 : " << b1.a3 << std::endl;// error: 'int A::a3' is private within this context           private成员不能在类外访问
  b1.fun();
  printf("----------end----------\n");
  // system("pause");
  return 0;
}